package cn.net.shuxing.yifu.common.util;

import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//字符串工具类
//这个工具类里的所有方法要求看懂并且可以自己写出来
//这个里的所有方法全是我自己手写出来的，要求你们也要可以手写出来
public class StringUtil {

    /**
     * 将字符串首字母转换成大写
     *
     * @param str 要转换的字符串
     * @return 返回str首字母大写后的字符串
     */
    public static String firstLetterToUpperCase(String str)
    {
        //这里只替换第一个
        return str.replaceFirst(String.valueOf(str.charAt(0)),String.valueOf(str.charAt(0)).toUpperCase());
    }

    /**
     * 将字符串首字母转换成小写
     *
     * @param str 要转换的字符串
     * @return 返回str首字母瞎写写后的字符串
     */
    public static String firstLetterToLowerCase(String str)
    {
        //这里只替换第一个
        return str.replaceFirst(String.valueOf(str.charAt(0)),String.valueOf(str.charAt(0)).toLowerCase());
    }

    /**
     * 驼峰转下划线
     *     解释下什么叫驼峰式，就是每个单词的首字母大写，其余字母都小写
     *     java推荐所有变量、方法、类都使用驼峰式命名
     *     类名一般第一个单词的首字母也要大写
     *     变量、方法第一个单词的首字母小写
     *     下划线式是指全字母小写或全字母大写，单词之间用下划线分割，如cast_camel_case_to_underline
     *     常量采用全字母大写加下划线式
     */


    /**
     * 将驼峰式字符串转换成下划线式
     *
     * @param str 驼峰式字符串
     * @return 下划线式字符串
     */
    public static String castCamelCaseToUnderline(String str)
    {
        char[] chars = str.toCharArray();
        String result = "";
        for (char i : chars)
        {
            if (i >= 'A' && i <= 'Z')
            {
                result += "_" + String.valueOf(i).toLowerCase();
            }
            else
            {
                result += i;
            }
        }
        if (result.startsWith("_"))
        {
            result = result.substring(1);
        }
        return result;
    }

    /**
     * 将下划线字符串转换成驼峰式
     *
     * @param str 下划线式字符串
     * @return 驼峰式字符串
     */
    public static String castUnderlineToCamelCase(String str)
    {
        String[] split = str.split("_");
        String result = "";
        for (String s : split)
        {
            result += firstLetterToUpperCase(s);
        }
        return firstLetterToLowerCase(result);
    }

    /**
     * 删除下划线最后length位字符
     *
     * @param str 要处理的字符串
     * @param length 要删除字符串最后多少位字符
     * @return 删除str字符串最后length位字符后的新字符串
     */
    public static String deleteLastChildString(String str,int length)
    {
        return str.substring(0,str.length() - length);
    }

    /**
     * 数值类型前面补零（共13位）
     * @param num
     * @return
     */
    public static String supplementZeroGenerateThirteen(int num){
        String str = String.format("%013d", num);

        return str;
    }

    /**
     * 数值类型前面补零（共16位）
     * @param num
     * @return
     */
    public static String supplementZeroGenerateSixteen(int num){
        String str = String.format("%016d", num);

        return str;
    }
    /**
     * 数值类型前面补零（共3位）
     * @param num
     * @return
     */
    public static String supplementZeroGenerateThree(int num){
        String str = String.format("%03d", num);

        return str;
    }

    /**
     * 判断字符串是不是double型
     * @param str
     * @return
     */
    public static boolean isNumeric(String str){
        Pattern pattern = Pattern.compile("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}");
        Matcher isNum = pattern.matcher(str);
        if( !isNum.matches() ){
            return false;
        }
        return true;
    }

    public static String trim(String str, boolean nullFlag){
        String tempStr = null;

        if (str != null)
        {
            tempStr = str.trim();
        }

        if (nullFlag)
        {
            if ("".equals(tempStr) || "null".equals(tempStr))
            {
                tempStr = null;
            }
        }
        else
        {
            if (tempStr == null)
            {
                tempStr = "";
            }
        }

        return tempStr;
    }
    public static String replace(String strSource, String strFrom, String strTo) {
        if(strSource==null){
            return null;
        }
        int i = 0;
        if ((i = strSource.indexOf(strFrom, i)) >= 0) {
            char[] cSrc = strSource.toCharArray();
            char[] cTo = strTo.toCharArray();
            int len = strFrom.length();
            StringBuffer buf = new StringBuffer(cSrc.length);
            buf.append(cSrc, 0, i).append(cTo);
            i += len;
            int j = i;
            while ((i = strSource.indexOf(strFrom, i)) > 0) {
                buf.append(cSrc, j, i - j).append(cTo);
                i += len;
                j = i;
            }
            buf.append(cSrc, j, cSrc.length - j);
            return buf.toString();
        }
        return strSource;
    }


    public static String deal(String str) {
        str = replace(str, "\\", "\\\\");
        str = replace(str, "'", "\\'");
        str = replace(str, "\r", "\\r");
        str = replace(str, "\n", "\\n");
        str = replace(str, "\"", "\\\"");
        return str;
    }

    public static String GetMapToXML(Map<String,String> param){
        StringBuffer sb = new StringBuffer();
        sb.append("<xml>");
        for (Map.Entry<String,String> entry : param.entrySet()) {
            sb.append("<"+ entry.getKey() +">");
            sb.append(entry.getValue());
            sb.append("</"+ entry.getKey() +">");
        }
        sb.append("</xml>");
        return sb.toString();
    }

    public static void main(String[] args){
        //String a = StringUtil.supplementZeroGenerateThirteen(1000);
        double a = 32.;
        System.out.println(StringUtil.isNumeric("32."));
        System.out.println(a);
    }

}

